// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: src/carnot/docspb/docs.proto

package docspb

import (
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	io "io"
	math "math"
	math_bits "math/bits"
	udfspb "px.dev/pixie/src/carnot/udfspb"
	reflect "reflect"
	strings "strings"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

type IdentDoc struct {
	Ident   string   `protobuf:"bytes,1,opt,name=ident,proto3" json:"ident,omitempty"`
	Desc    string   `protobuf:"bytes,2,opt,name=desc,proto3" json:"desc,omitempty"`
	Types   []string `protobuf:"bytes,3,rep,name=types,proto3" json:"types,omitempty"`
	Default string   `protobuf:"bytes,4,opt,name=default,proto3" json:"default,omitempty"`
}

func (m *IdentDoc) Reset()      { *m = IdentDoc{} }
func (*IdentDoc) ProtoMessage() {}
func (*IdentDoc) Descriptor() ([]byte, []int) {
	return fileDescriptor_af0569155e5909a2, []int{0}
}
func (m *IdentDoc) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *IdentDoc) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_IdentDoc.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *IdentDoc) XXX_Merge(src proto.Message) {
	xxx_messageInfo_IdentDoc.Merge(m, src)
}
func (m *IdentDoc) XXX_Size() int {
	return m.Size()
}
func (m *IdentDoc) XXX_DiscardUnknown() {
	xxx_messageInfo_IdentDoc.DiscardUnknown(m)
}

var xxx_messageInfo_IdentDoc proto.InternalMessageInfo

func (m *IdentDoc) GetIdent() string {
	if m != nil {
		return m.Ident
	}
	return ""
}

func (m *IdentDoc) GetDesc() string {
	if m != nil {
		return m.Desc
	}
	return ""
}

func (m *IdentDoc) GetTypes() []string {
	if m != nil {
		return m.Types
	}
	return nil
}

func (m *IdentDoc) GetDefault() string {
	if m != nil {
		return m.Default
	}
	return ""
}

type FuncDoc struct {
	Args         []*IdentDoc `protobuf:"bytes,1,rep,name=args,proto3" json:"args,omitempty"`
	RepeatedArgs *IdentDoc   `protobuf:"bytes,2,opt,name=repeated_args,json=repeatedArgs,proto3" json:"repeated_args,omitempty"`
	Kwargs       *IdentDoc   `protobuf:"bytes,3,opt,name=kwargs,proto3" json:"kwargs,omitempty"`
	ReturnType   *IdentDoc   `protobuf:"bytes,4,opt,name=return_type,json=returnType,proto3" json:"return_type,omitempty"`
}

func (m *FuncDoc) Reset()      { *m = FuncDoc{} }
func (*FuncDoc) ProtoMessage() {}
func (*FuncDoc) Descriptor() ([]byte, []int) {
	return fileDescriptor_af0569155e5909a2, []int{1}
}
func (m *FuncDoc) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FuncDoc) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_FuncDoc.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *FuncDoc) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FuncDoc.Merge(m, src)
}
func (m *FuncDoc) XXX_Size() int {
	return m.Size()
}
func (m *FuncDoc) XXX_DiscardUnknown() {
	xxx_messageInfo_FuncDoc.DiscardUnknown(m)
}

var xxx_messageInfo_FuncDoc proto.InternalMessageInfo

func (m *FuncDoc) GetArgs() []*IdentDoc {
	if m != nil {
		return m.Args
	}
	return nil
}

func (m *FuncDoc) GetRepeatedArgs() *IdentDoc {
	if m != nil {
		return m.RepeatedArgs
	}
	return nil
}

func (m *FuncDoc) GetKwargs() *IdentDoc {
	if m != nil {
		return m.Kwargs
	}
	return nil
}

func (m *FuncDoc) GetReturnType() *IdentDoc {
	if m != nil {
		return m.ReturnType
	}
	return nil
}

type DocstringNode struct {
	Name      string           `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Docstring string           `protobuf:"bytes,2,opt,name=docstring,proto3" json:"docstring,omitempty"`
	Children  []*DocstringNode `protobuf:"bytes,3,rep,name=children,proto3" json:"children,omitempty"`
}

func (m *DocstringNode) Reset()      { *m = DocstringNode{} }
func (*DocstringNode) ProtoMessage() {}
func (*DocstringNode) Descriptor() ([]byte, []int) {
	return fileDescriptor_af0569155e5909a2, []int{2}
}
func (m *DocstringNode) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DocstringNode) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DocstringNode.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DocstringNode) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DocstringNode.Merge(m, src)
}
func (m *DocstringNode) XXX_Size() int {
	return m.Size()
}
func (m *DocstringNode) XXX_DiscardUnknown() {
	xxx_messageInfo_DocstringNode.DiscardUnknown(m)
}

var xxx_messageInfo_DocstringNode proto.InternalMessageInfo

func (m *DocstringNode) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *DocstringNode) GetDocstring() string {
	if m != nil {
		return m.Docstring
	}
	return ""
}

func (m *DocstringNode) GetChildren() []*DocstringNode {
	if m != nil {
		return m.Children
	}
	return nil
}

type InternalPXLDocs struct {
	DocstringNodes []*DocstringNode `protobuf:"bytes,1,rep,name=docstring_nodes,json=docstringNodes,proto3" json:"docstring_nodes,omitempty"`
	UdfDocs        *udfspb.Docs     `protobuf:"bytes,2,opt,name=udf_docs,json=udfDocs,proto3" json:"udf_docs,omitempty"`
}

func (m *InternalPXLDocs) Reset()      { *m = InternalPXLDocs{} }
func (*InternalPXLDocs) ProtoMessage() {}
func (*InternalPXLDocs) Descriptor() ([]byte, []int) {
	return fileDescriptor_af0569155e5909a2, []int{3}
}
func (m *InternalPXLDocs) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *InternalPXLDocs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_InternalPXLDocs.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *InternalPXLDocs) XXX_Merge(src proto.Message) {
	xxx_messageInfo_InternalPXLDocs.Merge(m, src)
}
func (m *InternalPXLDocs) XXX_Size() int {
	return m.Size()
}
func (m *InternalPXLDocs) XXX_DiscardUnknown() {
	xxx_messageInfo_InternalPXLDocs.DiscardUnknown(m)
}

var xxx_messageInfo_InternalPXLDocs proto.InternalMessageInfo

func (m *InternalPXLDocs) GetDocstringNodes() []*DocstringNode {
	if m != nil {
		return m.DocstringNodes
	}
	return nil
}

func (m *InternalPXLDocs) GetUdfDocs() *udfspb.Docs {
	if m != nil {
		return m.UdfDocs
	}
	return nil
}

type ExampleDoc struct {
	Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
}

func (m *ExampleDoc) Reset()      { *m = ExampleDoc{} }
func (*ExampleDoc) ProtoMessage() {}
func (*ExampleDoc) Descriptor() ([]byte, []int) {
	return fileDescriptor_af0569155e5909a2, []int{4}
}
func (m *ExampleDoc) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ExampleDoc) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ExampleDoc.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ExampleDoc) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExampleDoc.Merge(m, src)
}
func (m *ExampleDoc) XXX_Size() int {
	return m.Size()
}
func (m *ExampleDoc) XXX_DiscardUnknown() {
	xxx_messageInfo_ExampleDoc.DiscardUnknown(m)
}

var xxx_messageInfo_ExampleDoc proto.InternalMessageInfo

func (m *ExampleDoc) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type DocBody struct {
	Name     string        `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Brief    string        `protobuf:"bytes,2,opt,name=brief,proto3" json:"brief,omitempty"`
	Desc     string        `protobuf:"bytes,3,opt,name=desc,proto3" json:"desc,omitempty"`
	Examples []*ExampleDoc `protobuf:"bytes,4,rep,name=examples,proto3" json:"examples,omitempty"`
}

func (m *DocBody) Reset()      { *m = DocBody{} }
func (*DocBody) ProtoMessage() {}
func (*DocBody) Descriptor() ([]byte, []int) {
	return fileDescriptor_af0569155e5909a2, []int{5}
}
func (m *DocBody) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DocBody) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DocBody.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DocBody) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DocBody.Merge(m, src)
}
func (m *DocBody) XXX_Size() int {
	return m.Size()
}
func (m *DocBody) XXX_DiscardUnknown() {
	xxx_messageInfo_DocBody.DiscardUnknown(m)
}

var xxx_messageInfo_DocBody proto.InternalMessageInfo

func (m *DocBody) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *DocBody) GetBrief() string {
	if m != nil {
		return m.Brief
	}
	return ""
}

func (m *DocBody) GetDesc() string {
	if m != nil {
		return m.Desc
	}
	return ""
}

func (m *DocBody) GetExamples() []*ExampleDoc {
	if m != nil {
		return m.Examples
	}
	return nil
}

type MutationDoc struct {
	Body    *DocBody `protobuf:"bytes,1,opt,name=body,proto3" json:"body,omitempty"`
	FuncDoc *FuncDoc `protobuf:"bytes,2,opt,name=func_doc,json=funcDoc,proto3" json:"func_doc,omitempty"`
}

func (m *MutationDoc) Reset()      { *m = MutationDoc{} }
func (*MutationDoc) ProtoMessage() {}
func (*MutationDoc) Descriptor() ([]byte, []int) {
	return fileDescriptor_af0569155e5909a2, []int{6}
}
func (m *MutationDoc) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MutationDoc) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MutationDoc.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MutationDoc) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MutationDoc.Merge(m, src)
}
func (m *MutationDoc) XXX_Size() int {
	return m.Size()
}
func (m *MutationDoc) XXX_DiscardUnknown() {
	xxx_messageInfo_MutationDoc.DiscardUnknown(m)
}

var xxx_messageInfo_MutationDoc proto.InternalMessageInfo

func (m *MutationDoc) GetBody() *DocBody {
	if m != nil {
		return m.Body
	}
	return nil
}

func (m *MutationDoc) GetFuncDoc() *FuncDoc {
	if m != nil {
		return m.FuncDoc
	}
	return nil
}

type TracepointDecoratorDoc struct {
	Body    *DocBody `protobuf:"bytes,1,opt,name=body,proto3" json:"body,omitempty"`
	FuncDoc *FuncDoc `protobuf:"bytes,2,opt,name=func_doc,json=funcDoc,proto3" json:"func_doc,omitempty"`
}

func (m *TracepointDecoratorDoc) Reset()      { *m = TracepointDecoratorDoc{} }
func (*TracepointDecoratorDoc) ProtoMessage() {}
func (*TracepointDecoratorDoc) Descriptor() ([]byte, []int) {
	return fileDescriptor_af0569155e5909a2, []int{7}
}
func (m *TracepointDecoratorDoc) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TracepointDecoratorDoc) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TracepointDecoratorDoc.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TracepointDecoratorDoc) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TracepointDecoratorDoc.Merge(m, src)
}
func (m *TracepointDecoratorDoc) XXX_Size() int {
	return m.Size()
}
func (m *TracepointDecoratorDoc) XXX_DiscardUnknown() {
	xxx_messageInfo_TracepointDecoratorDoc.DiscardUnknown(m)
}

var xxx_messageInfo_TracepointDecoratorDoc proto.InternalMessageInfo

func (m *TracepointDecoratorDoc) GetBody() *DocBody {
	if m != nil {
		return m.Body
	}
	return nil
}

func (m *TracepointDecoratorDoc) GetFuncDoc() *FuncDoc {
	if m != nil {
		return m.FuncDoc
	}
	return nil
}

type TracepointFieldDoc struct {
	Body    *DocBody `protobuf:"bytes,1,opt,name=body,proto3" json:"body,omitempty"`
	FuncDoc *FuncDoc `protobuf:"bytes,2,opt,name=func_doc,json=funcDoc,proto3" json:"func_doc,omitempty"`
}

func (m *TracepointFieldDoc) Reset()      { *m = TracepointFieldDoc{} }
func (*TracepointFieldDoc) ProtoMessage() {}
func (*TracepointFieldDoc) Descriptor() ([]byte, []int) {
	return fileDescriptor_af0569155e5909a2, []int{8}
}
func (m *TracepointFieldDoc) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TracepointFieldDoc) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TracepointFieldDoc.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TracepointFieldDoc) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TracepointFieldDoc.Merge(m, src)
}
func (m *TracepointFieldDoc) XXX_Size() int {
	return m.Size()
}
func (m *TracepointFieldDoc) XXX_DiscardUnknown() {
	xxx_messageInfo_TracepointFieldDoc.DiscardUnknown(m)
}

var xxx_messageInfo_TracepointFieldDoc proto.InternalMessageInfo

func (m *TracepointFieldDoc) GetBody() *DocBody {
	if m != nil {
		return m.Body
	}
	return nil
}

func (m *TracepointFieldDoc) GetFuncDoc() *FuncDoc {
	if m != nil {
		return m.FuncDoc
	}
	return nil
}

type DataFrameOpDoc struct {
	Body    *DocBody `protobuf:"bytes,1,opt,name=body,proto3" json:"body,omitempty"`
	FuncDoc *FuncDoc `protobuf:"bytes,2,opt,name=func_doc,json=funcDoc,proto3" json:"func_doc,omitempty"`
}

func (m *DataFrameOpDoc) Reset()      { *m = DataFrameOpDoc{} }
func (*DataFrameOpDoc) ProtoMessage() {}
func (*DataFrameOpDoc) Descriptor() ([]byte, []int) {
	return fileDescriptor_af0569155e5909a2, []int{9}
}
func (m *DataFrameOpDoc) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DataFrameOpDoc) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DataFrameOpDoc.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DataFrameOpDoc) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DataFrameOpDoc.Merge(m, src)
}
func (m *DataFrameOpDoc) XXX_Size() int {
	return m.Size()
}
func (m *DataFrameOpDoc) XXX_DiscardUnknown() {
	xxx_messageInfo_DataFrameOpDoc.DiscardUnknown(m)
}

var xxx_messageInfo_DataFrameOpDoc proto.InternalMessageInfo

func (m *DataFrameOpDoc) GetBody() *DocBody {
	if m != nil {
		return m.Body
	}
	return nil
}

func (m *DataFrameOpDoc) GetFuncDoc() *FuncDoc {
	if m != nil {
		return m.FuncDoc
	}
	return nil
}

type CompileFnDoc struct {
	Body    *DocBody `protobuf:"bytes,1,opt,name=body,proto3" json:"body,omitempty"`
	FuncDoc *FuncDoc `protobuf:"bytes,2,opt,name=func_doc,json=funcDoc,proto3" json:"func_doc,omitempty"`
}

func (m *CompileFnDoc) Reset()      { *m = CompileFnDoc{} }
func (*CompileFnDoc) ProtoMessage() {}
func (*CompileFnDoc) Descriptor() ([]byte, []int) {
	return fileDescriptor_af0569155e5909a2, []int{10}
}
func (m *CompileFnDoc) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CompileFnDoc) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CompileFnDoc.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CompileFnDoc) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CompileFnDoc.Merge(m, src)
}
func (m *CompileFnDoc) XXX_Size() int {
	return m.Size()
}
func (m *CompileFnDoc) XXX_DiscardUnknown() {
	xxx_messageInfo_CompileFnDoc.DiscardUnknown(m)
}

var xxx_messageInfo_CompileFnDoc proto.InternalMessageInfo

func (m *CompileFnDoc) GetBody() *DocBody {
	if m != nil {
		return m.Body
	}
	return nil
}

func (m *CompileFnDoc) GetFuncDoc() *FuncDoc {
	if m != nil {
		return m.FuncDoc
	}
	return nil
}

type OTelDoc struct {
	Body    *DocBody `protobuf:"bytes,1,opt,name=body,proto3" json:"body,omitempty"`
	FuncDoc *FuncDoc `protobuf:"bytes,2,opt,name=func_doc,json=funcDoc,proto3" json:"func_doc,omitempty"`
}

func (m *OTelDoc) Reset()      { *m = OTelDoc{} }
func (*OTelDoc) ProtoMessage() {}
func (*OTelDoc) Descriptor() ([]byte, []int) {
	return fileDescriptor_af0569155e5909a2, []int{11}
}
func (m *OTelDoc) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *OTelDoc) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_OTelDoc.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *OTelDoc) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OTelDoc.Merge(m, src)
}
func (m *OTelDoc) XXX_Size() int {
	return m.Size()
}
func (m *OTelDoc) XXX_DiscardUnknown() {
	xxx_messageInfo_OTelDoc.DiscardUnknown(m)
}

var xxx_messageInfo_OTelDoc proto.InternalMessageInfo

func (m *OTelDoc) GetBody() *DocBody {
	if m != nil {
		return m.Body
	}
	return nil
}

func (m *OTelDoc) GetFuncDoc() *FuncDoc {
	if m != nil {
		return m.FuncDoc
	}
	return nil
}

type StructuredDocs struct {
	MutationDocs            []*MutationDoc            `protobuf:"bytes,1,rep,name=mutation_docs,json=mutationDocs,proto3" json:"mutation_docs,omitempty"`
	TracepointDecoratorDocs []*TracepointDecoratorDoc `protobuf:"bytes,2,rep,name=tracepoint_decorator_docs,json=tracepointDecoratorDocs,proto3" json:"tracepoint_decorator_docs,omitempty"`
	TracepointFieldDocs     []*TracepointFieldDoc     `protobuf:"bytes,3,rep,name=tracepoint_field_docs,json=tracepointFieldDocs,proto3" json:"tracepoint_field_docs,omitempty"`
	DataframeOpDocs         []*DataFrameOpDoc         `protobuf:"bytes,5,rep,name=dataframe_op_docs,json=dataframeOpDocs,proto3" json:"dataframe_op_docs,omitempty"`
	CompileFnDocs           []*CompileFnDoc           `protobuf:"bytes,6,rep,name=compile_fn_docs,json=compileFnDocs,proto3" json:"compile_fn_docs,omitempty"`
	UdfDocs                 *udfspb.Docs              `protobuf:"bytes,4,opt,name=udf_docs,json=udfDocs,proto3" json:"udf_docs,omitempty"`
	OTelDocs                []*OTelDoc                `protobuf:"bytes,7,rep,name=otel_docs,json=otelDocs,proto3" json:"otel_docs,omitempty"`
}

func (m *StructuredDocs) Reset()      { *m = StructuredDocs{} }
func (*StructuredDocs) ProtoMessage() {}
func (*StructuredDocs) Descriptor() ([]byte, []int) {
	return fileDescriptor_af0569155e5909a2, []int{12}
}
func (m *StructuredDocs) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *StructuredDocs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_StructuredDocs.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *StructuredDocs) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StructuredDocs.Merge(m, src)
}
func (m *StructuredDocs) XXX_Size() int {
	return m.Size()
}
func (m *StructuredDocs) XXX_DiscardUnknown() {
	xxx_messageInfo_StructuredDocs.DiscardUnknown(m)
}

var xxx_messageInfo_StructuredDocs proto.InternalMessageInfo

func (m *StructuredDocs) GetMutationDocs() []*MutationDoc {
	if m != nil {
		return m.MutationDocs
	}
	return nil
}

func (m *StructuredDocs) GetTracepointDecoratorDocs() []*TracepointDecoratorDoc {
	if m != nil {
		return m.TracepointDecoratorDocs
	}
	return nil
}

func (m *StructuredDocs) GetTracepointFieldDocs() []*TracepointFieldDoc {
	if m != nil {
		return m.TracepointFieldDocs
	}
	return nil
}

func (m *StructuredDocs) GetDataframeOpDocs() []*DataFrameOpDoc {
	if m != nil {
		return m.DataframeOpDocs
	}
	return nil
}

func (m *StructuredDocs) GetCompileFnDocs() []*CompileFnDoc {
	if m != nil {
		return m.CompileFnDocs
	}
	return nil
}

func (m *StructuredDocs) GetUdfDocs() *udfspb.Docs {
	if m != nil {
		return m.UdfDocs
	}
	return nil
}

func (m *StructuredDocs) GetOTelDocs() []*OTelDoc {
	if m != nil {
		return m.OTelDocs
	}
	return nil
}

func init() {
	proto.RegisterType((*IdentDoc)(nil), "px.carnot.docspb.IdentDoc")
	proto.RegisterType((*FuncDoc)(nil), "px.carnot.docspb.FuncDoc")
	proto.RegisterType((*DocstringNode)(nil), "px.carnot.docspb.DocstringNode")
	proto.RegisterType((*InternalPXLDocs)(nil), "px.carnot.docspb.InternalPXLDocs")
	proto.RegisterType((*ExampleDoc)(nil), "px.carnot.docspb.ExampleDoc")
	proto.RegisterType((*DocBody)(nil), "px.carnot.docspb.DocBody")
	proto.RegisterType((*MutationDoc)(nil), "px.carnot.docspb.MutationDoc")
	proto.RegisterType((*TracepointDecoratorDoc)(nil), "px.carnot.docspb.TracepointDecoratorDoc")
	proto.RegisterType((*TracepointFieldDoc)(nil), "px.carnot.docspb.TracepointFieldDoc")
	proto.RegisterType((*DataFrameOpDoc)(nil), "px.carnot.docspb.DataFrameOpDoc")
	proto.RegisterType((*CompileFnDoc)(nil), "px.carnot.docspb.CompileFnDoc")
	proto.RegisterType((*OTelDoc)(nil), "px.carnot.docspb.OTelDoc")
	proto.RegisterType((*StructuredDocs)(nil), "px.carnot.docspb.StructuredDocs")
}

func init() { proto.RegisterFile("src/carnot/docspb/docs.proto", fileDescriptor_af0569155e5909a2) }

var fileDescriptor_af0569155e5909a2 = []byte{
	// 803 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x56, 0xc1, 0x6e, 0xeb, 0x44,
	0x14, 0x8d, 0x49, 0x9a, 0xa4, 0x37, 0x49, 0x03, 0xc3, 0xe3, 0x91, 0x57, 0x15, 0x37, 0xb2, 0x58,
	0x74, 0xd3, 0x44, 0x04, 0x16, 0x48, 0x45, 0x42, 0x84, 0x10, 0x51, 0xa9, 0x50, 0x64, 0xba, 0xa8,
	0xd8, 0x44, 0x93, 0x99, 0x71, 0x6a, 0xe1, 0x78, 0xac, 0xf1, 0x18, 0x9a, 0x05, 0x08, 0x7e, 0x00,
	0xf1, 0x0f, 0x6c, 0xf8, 0x14, 0x96, 0x5d, 0x76, 0x85, 0xa8, 0xbb, 0x41, 0x62, 0xd3, 0x4f, 0x40,
	0x33, 0x63, 0x27, 0x2e, 0x89, 0x5a, 0x56, 0x59, 0xe5, 0x9e, 0xf1, 0xbd, 0xe7, 0xdc, 0xb9, 0x73,
	0x66, 0x14, 0x38, 0x88, 0x05, 0xe9, 0x13, 0x2c, 0x42, 0x2e, 0xfb, 0x94, 0x93, 0x38, 0x9a, 0xea,
	0x9f, 0x5e, 0x24, 0xb8, 0xe4, 0xe8, 0xf5, 0xe8, 0xba, 0x67, 0x3e, 0xf6, 0xcc, 0xc7, 0xfd, 0xe3,
	0x99, 0x2f, 0xaf, 0x92, 0x69, 0x8f, 0xf0, 0x79, 0x7f, 0xc6, 0x67, 0xbc, 0xaf, 0x13, 0xa7, 0x89,
	0xa7, 0x91, 0x06, 0x3a, 0x32, 0x04, 0xfb, 0x45, 0xfa, 0x84, 0x7a, 0x8a, 0x5e, 0xfd, 0x98, 0xaf,
	0x0e, 0x85, 0xfa, 0x29, 0x65, 0xa1, 0x1c, 0x71, 0x82, 0x5e, 0xc0, 0x8e, 0xaf, 0xe2, 0x8e, 0xd5,
	0xb5, 0x8e, 0x76, 0x5d, 0x03, 0x10, 0x82, 0x0a, 0x65, 0x31, 0xe9, 0xbc, 0xa6, 0x17, 0x75, 0xac,
	0x32, 0xe5, 0x22, 0x62, 0x71, 0xa7, 0xdc, 0x2d, 0xab, 0x4c, 0x0d, 0x50, 0x07, 0x6a, 0x94, 0x79,
	0x38, 0x09, 0x64, 0xa7, 0xa2, 0x93, 0x73, 0xe8, 0xfc, 0x63, 0x41, 0x6d, 0x9c, 0x84, 0x44, 0xa9,
	0xf4, 0xa0, 0x82, 0xc5, 0x2c, 0xee, 0x58, 0xdd, 0xf2, 0x51, 0x63, 0xb0, 0xdf, 0xfb, 0xef, 0xfe,
	0x7a, 0x79, 0x3f, 0xae, 0xce, 0x43, 0x1f, 0x43, 0x4b, 0xb0, 0x88, 0x61, 0xc9, 0xe8, 0x44, 0x17,
	0xaa, 0x46, 0x9e, 0x2e, 0x6c, 0xe6, 0x05, 0x9f, 0x28, 0x82, 0x01, 0x54, 0xbf, 0xfd, 0x5e, 0x57,
	0x96, 0x9f, 0xad, 0xcc, 0x32, 0xd1, 0x09, 0x34, 0x04, 0x93, 0x89, 0x08, 0x27, 0x6a, 0x6b, 0x7a,
	0x3b, 0x4f, 0x17, 0x82, 0x49, 0xbf, 0x58, 0x44, 0xcc, 0xf9, 0x11, 0x5a, 0x23, 0x4e, 0x62, 0x29,
	0xfc, 0x70, 0xf6, 0x25, 0xa7, 0x4c, 0x8d, 0x30, 0xc4, 0x73, 0x96, 0xcd, 0x55, 0xc7, 0xe8, 0x00,
	0x76, 0x69, 0x9e, 0x94, 0xcd, 0x76, 0xb5, 0x80, 0x4e, 0xa0, 0x4e, 0xae, 0xfc, 0x80, 0x0a, 0x16,
	0xea, 0x19, 0x37, 0x06, 0x87, 0xeb, 0xe2, 0x8f, 0x44, 0xdc, 0x65, 0x81, 0xf3, 0x8b, 0x05, 0xed,
	0xd3, 0x50, 0x32, 0x11, 0xe2, 0xe0, 0xab, 0xcb, 0x33, 0x95, 0x86, 0x3e, 0x87, 0xf6, 0x92, 0x7d,
	0x12, 0x72, 0xca, 0xf2, 0x03, 0x78, 0x96, 0x77, 0x8f, 0x16, 0x61, 0x8c, 0xde, 0x83, 0x7a, 0x42,
	0xbd, 0x89, 0x5a, 0xcd, 0x8e, 0xe2, 0x65, 0x81, 0xc2, 0x38, 0x4c, 0x53, 0xb8, 0xb5, 0x84, 0x7a,
	0x2a, 0x70, 0x1c, 0x80, 0xcf, 0xae, 0xf1, 0x3c, 0x0a, 0x58, 0x66, 0xb3, 0xef, 0x70, 0x90, 0xe4,
	0xe3, 0x30, 0xc0, 0xf9, 0xd9, 0x82, 0xda, 0x88, 0x93, 0x21, 0xa7, 0x8b, 0x8d, 0xf3, 0x7a, 0x01,
	0x3b, 0x53, 0xe1, 0x33, 0x2f, 0x9b, 0x95, 0x01, 0x4b, 0x73, 0x96, 0x0b, 0xe6, 0xfc, 0x10, 0xea,
	0xcc, 0xa8, 0xc5, 0x9d, 0x8a, 0xde, 0xe3, 0xc1, 0xfa, 0x1e, 0x57, 0xfd, 0xb8, 0xcb, 0x6c, 0x47,
	0x40, 0xe3, 0x8b, 0x44, 0x62, 0xe9, 0xf3, 0x50, 0x35, 0x7a, 0x0c, 0x95, 0x29, 0xa7, 0x0b, 0xdd,
	0x46, 0x63, 0xf0, 0x6a, 0xe3, 0xa0, 0x54, 0xbf, 0xae, 0x4e, 0x43, 0x1f, 0x40, 0xdd, 0x4b, 0x42,
	0xa2, 0x26, 0x93, 0x0d, 0x66, 0x43, 0x49, 0x76, 0x0b, 0xdc, 0x9a, 0x67, 0x02, 0xe7, 0x07, 0x78,
	0x79, 0x21, 0x30, 0x61, 0x11, 0xf7, 0x43, 0x39, 0x62, 0x84, 0x0b, 0x2c, 0xb9, 0xd8, 0x9a, 0xfc,
	0x02, 0xd0, 0x4a, 0x7e, 0xec, 0xb3, 0x80, 0x6e, 0x4d, 0x3a, 0x81, 0xbd, 0x11, 0x96, 0x78, 0x2c,
	0xf0, 0x9c, 0x9d, 0x47, 0x5b, 0x93, 0x8d, 0xa1, 0xf9, 0x29, 0x9f, 0x47, 0x7e, 0xc0, 0xc6, 0xdb,
	0x3b, 0xe5, 0x10, 0x6a, 0xe7, 0x17, 0x2c, 0xd8, 0x9a, 0xde, 0x6f, 0x15, 0xd8, 0xfb, 0x5a, 0x8a,
	0x84, 0xc8, 0x44, 0x30, 0xaa, 0x5f, 0x80, 0x21, 0xb4, 0xe6, 0x99, 0xb9, 0xcd, 0xe5, 0x35, 0xf7,
	0xff, 0x9d, 0x75, 0xb6, 0xc2, 0x1d, 0x70, 0x9b, 0xf3, 0x15, 0x88, 0x11, 0x85, 0x57, 0x72, 0xe9,
	0x96, 0x09, 0xcd, 0xdd, 0x9a, 0x3f, 0x06, 0x8a, 0xef, 0x68, 0x9d, 0x6f, 0xb3, 0xbf, 0xdd, 0xb7,
	0xe5, 0xc6, 0xf5, 0x18, 0x5d, 0xc2, 0x5b, 0x05, 0x15, 0x4f, 0x99, 0xd2, 0x28, 0x98, 0x97, 0xf0,
	0xdd, 0xa7, 0x14, 0x72, 0x0b, 0xbb, 0x6f, 0xca, 0xb5, 0xb5, 0x18, 0x9d, 0xc1, 0x1b, 0x14, 0x4b,
	0xec, 0x29, 0xcb, 0x4d, 0x78, 0x64, 0x58, 0x77, 0x34, 0x6b, 0x77, 0xc3, 0x41, 0x3c, 0x72, 0xa7,
	0xdb, 0x5e, 0x96, 0x6a, 0x1c, 0xa3, 0x31, 0xb4, 0x89, 0x71, 0xd2, 0xc4, 0xcb, 0x66, 0x5a, 0xd5,
	0x5c, 0xf6, 0x3a, 0x57, 0xd1, 0x72, 0x6e, 0x8b, 0x14, 0xd0, 0xe3, 0x17, 0xb5, 0xf2, 0xbf, 0x5e,
	0x54, 0x34, 0x82, 0x5d, 0x2e, 0x59, 0x60, 0x6a, 0x6a, 0x5a, 0x74, 0x83, 0x2d, 0x32, 0xcb, 0x0d,
	0x9b, 0xe9, 0x9f, 0x87, 0xf5, 0x0c, 0xc4, 0x6e, 0x5d, 0x55, 0xaa, 0x68, 0xf8, 0xd1, 0xcd, 0x9d,
	0x5d, 0xba, 0xbd, 0xb3, 0x4b, 0x0f, 0x77, 0xb6, 0xf5, 0x53, 0x6a, 0x5b, 0xbf, 0xa7, 0xb6, 0xf5,
	0x47, 0x6a, 0x5b, 0x37, 0xa9, 0x6d, 0xfd, 0x95, 0xda, 0xd6, 0xdf, 0xa9, 0x5d, 0x7a, 0x48, 0x6d,
	0xeb, 0xd7, 0x7b, 0xbb, 0x74, 0x73, 0x6f, 0x97, 0x6e, 0xef, 0xed, 0xd2, 0x37, 0x55, 0xc3, 0x3e,
	0xad, 0xea, 0x7f, 0x10, 0xef, 0xff, 0x1b, 0x00, 0x00, 0xff, 0xff, 0x82, 0x99, 0x88, 0x26, 0xc0,
	0x08, 0x00, 0x00,
}

func (this *IdentDoc) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*IdentDoc)
	if !ok {
		that2, ok := that.(IdentDoc)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Ident != that1.Ident {
		return false
	}
	if this.Desc != that1.Desc {
		return false
	}
	if len(this.Types) != len(that1.Types) {
		return false
	}
	for i := range this.Types {
		if this.Types[i] != that1.Types[i] {
			return false
		}
	}
	if this.Default != that1.Default {
		return false
	}
	return true
}
func (this *FuncDoc) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*FuncDoc)
	if !ok {
		that2, ok := that.(FuncDoc)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Args) != len(that1.Args) {
		return false
	}
	for i := range this.Args {
		if !this.Args[i].Equal(that1.Args[i]) {
			return false
		}
	}
	if !this.RepeatedArgs.Equal(that1.RepeatedArgs) {
		return false
	}
	if !this.Kwargs.Equal(that1.Kwargs) {
		return false
	}
	if !this.ReturnType.Equal(that1.ReturnType) {
		return false
	}
	return true
}
func (this *DocstringNode) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DocstringNode)
	if !ok {
		that2, ok := that.(DocstringNode)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.Docstring != that1.Docstring {
		return false
	}
	if len(this.Children) != len(that1.Children) {
		return false
	}
	for i := range this.Children {
		if !this.Children[i].Equal(that1.Children[i]) {
			return false
		}
	}
	return true
}
func (this *InternalPXLDocs) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*InternalPXLDocs)
	if !ok {
		that2, ok := that.(InternalPXLDocs)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.DocstringNodes) != len(that1.DocstringNodes) {
		return false
	}
	for i := range this.DocstringNodes {
		if !this.DocstringNodes[i].Equal(that1.DocstringNodes[i]) {
			return false
		}
	}
	if !this.UdfDocs.Equal(that1.UdfDocs) {
		return false
	}
	return true
}
func (this *ExampleDoc) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ExampleDoc)
	if !ok {
		that2, ok := that.(ExampleDoc)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Value != that1.Value {
		return false
	}
	return true
}
func (this *DocBody) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DocBody)
	if !ok {
		that2, ok := that.(DocBody)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Name != that1.Name {
		return false
	}
	if this.Brief != that1.Brief {
		return false
	}
	if this.Desc != that1.Desc {
		return false
	}
	if len(this.Examples) != len(that1.Examples) {
		return false
	}
	for i := range this.Examples {
		if !this.Examples[i].Equal(that1.Examples[i]) {
			return false
		}
	}
	return true
}
func (this *MutationDoc) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*MutationDoc)
	if !ok {
		that2, ok := that.(MutationDoc)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Body.Equal(that1.Body) {
		return false
	}
	if !this.FuncDoc.Equal(that1.FuncDoc) {
		return false
	}
	return true
}
func (this *TracepointDecoratorDoc) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*TracepointDecoratorDoc)
	if !ok {
		that2, ok := that.(TracepointDecoratorDoc)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Body.Equal(that1.Body) {
		return false
	}
	if !this.FuncDoc.Equal(that1.FuncDoc) {
		return false
	}
	return true
}
func (this *TracepointFieldDoc) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*TracepointFieldDoc)
	if !ok {
		that2, ok := that.(TracepointFieldDoc)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Body.Equal(that1.Body) {
		return false
	}
	if !this.FuncDoc.Equal(that1.FuncDoc) {
		return false
	}
	return true
}
func (this *DataFrameOpDoc) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DataFrameOpDoc)
	if !ok {
		that2, ok := that.(DataFrameOpDoc)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Body.Equal(that1.Body) {
		return false
	}
	if !this.FuncDoc.Equal(that1.FuncDoc) {
		return false
	}
	return true
}
func (this *CompileFnDoc) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*CompileFnDoc)
	if !ok {
		that2, ok := that.(CompileFnDoc)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Body.Equal(that1.Body) {
		return false
	}
	if !this.FuncDoc.Equal(that1.FuncDoc) {
		return false
	}
	return true
}
func (this *OTelDoc) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*OTelDoc)
	if !ok {
		that2, ok := that.(OTelDoc)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Body.Equal(that1.Body) {
		return false
	}
	if !this.FuncDoc.Equal(that1.FuncDoc) {
		return false
	}
	return true
}
func (this *StructuredDocs) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*StructuredDocs)
	if !ok {
		that2, ok := that.(StructuredDocs)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.MutationDocs) != len(that1.MutationDocs) {
		return false
	}
	for i := range this.MutationDocs {
		if !this.MutationDocs[i].Equal(that1.MutationDocs[i]) {
			return false
		}
	}
	if len(this.TracepointDecoratorDocs) != len(that1.TracepointDecoratorDocs) {
		return false
	}
	for i := range this.TracepointDecoratorDocs {
		if !this.TracepointDecoratorDocs[i].Equal(that1.TracepointDecoratorDocs[i]) {
			return false
		}
	}
	if len(this.TracepointFieldDocs) != len(that1.TracepointFieldDocs) {
		return false
	}
	for i := range this.TracepointFieldDocs {
		if !this.TracepointFieldDocs[i].Equal(that1.TracepointFieldDocs[i]) {
			return false
		}
	}
	if len(this.DataframeOpDocs) != len(that1.DataframeOpDocs) {
		return false
	}
	for i := range this.DataframeOpDocs {
		if !this.DataframeOpDocs[i].Equal(that1.DataframeOpDocs[i]) {
			return false
		}
	}
	if len(this.CompileFnDocs) != len(that1.CompileFnDocs) {
		return false
	}
	for i := range this.CompileFnDocs {
		if !this.CompileFnDocs[i].Equal(that1.CompileFnDocs[i]) {
			return false
		}
	}
	if !this.UdfDocs.Equal(that1.UdfDocs) {
		return false
	}
	if len(this.OTelDocs) != len(that1.OTelDocs) {
		return false
	}
	for i := range this.OTelDocs {
		if !this.OTelDocs[i].Equal(that1.OTelDocs[i]) {
			return false
		}
	}
	return true
}
func (this *IdentDoc) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&docspb.IdentDoc{")
	s = append(s, "Ident: "+fmt.Sprintf("%#v", this.Ident)+",\n")
	s = append(s, "Desc: "+fmt.Sprintf("%#v", this.Desc)+",\n")
	s = append(s, "Types: "+fmt.Sprintf("%#v", this.Types)+",\n")
	s = append(s, "Default: "+fmt.Sprintf("%#v", this.Default)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *FuncDoc) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&docspb.FuncDoc{")
	if this.Args != nil {
		s = append(s, "Args: "+fmt.Sprintf("%#v", this.Args)+",\n")
	}
	if this.RepeatedArgs != nil {
		s = append(s, "RepeatedArgs: "+fmt.Sprintf("%#v", this.RepeatedArgs)+",\n")
	}
	if this.Kwargs != nil {
		s = append(s, "Kwargs: "+fmt.Sprintf("%#v", this.Kwargs)+",\n")
	}
	if this.ReturnType != nil {
		s = append(s, "ReturnType: "+fmt.Sprintf("%#v", this.ReturnType)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DocstringNode) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&docspb.DocstringNode{")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "Docstring: "+fmt.Sprintf("%#v", this.Docstring)+",\n")
	if this.Children != nil {
		s = append(s, "Children: "+fmt.Sprintf("%#v", this.Children)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *InternalPXLDocs) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&docspb.InternalPXLDocs{")
	if this.DocstringNodes != nil {
		s = append(s, "DocstringNodes: "+fmt.Sprintf("%#v", this.DocstringNodes)+",\n")
	}
	if this.UdfDocs != nil {
		s = append(s, "UdfDocs: "+fmt.Sprintf("%#v", this.UdfDocs)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ExampleDoc) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&docspb.ExampleDoc{")
	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DocBody) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&docspb.DocBody{")
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "Brief: "+fmt.Sprintf("%#v", this.Brief)+",\n")
	s = append(s, "Desc: "+fmt.Sprintf("%#v", this.Desc)+",\n")
	if this.Examples != nil {
		s = append(s, "Examples: "+fmt.Sprintf("%#v", this.Examples)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *MutationDoc) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&docspb.MutationDoc{")
	if this.Body != nil {
		s = append(s, "Body: "+fmt.Sprintf("%#v", this.Body)+",\n")
	}
	if this.FuncDoc != nil {
		s = append(s, "FuncDoc: "+fmt.Sprintf("%#v", this.FuncDoc)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *TracepointDecoratorDoc) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&docspb.TracepointDecoratorDoc{")
	if this.Body != nil {
		s = append(s, "Body: "+fmt.Sprintf("%#v", this.Body)+",\n")
	}
	if this.FuncDoc != nil {
		s = append(s, "FuncDoc: "+fmt.Sprintf("%#v", this.FuncDoc)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *TracepointFieldDoc) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&docspb.TracepointFieldDoc{")
	if this.Body != nil {
		s = append(s, "Body: "+fmt.Sprintf("%#v", this.Body)+",\n")
	}
	if this.FuncDoc != nil {
		s = append(s, "FuncDoc: "+fmt.Sprintf("%#v", this.FuncDoc)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DataFrameOpDoc) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&docspb.DataFrameOpDoc{")
	if this.Body != nil {
		s = append(s, "Body: "+fmt.Sprintf("%#v", this.Body)+",\n")
	}
	if this.FuncDoc != nil {
		s = append(s, "FuncDoc: "+fmt.Sprintf("%#v", this.FuncDoc)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *CompileFnDoc) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&docspb.CompileFnDoc{")
	if this.Body != nil {
		s = append(s, "Body: "+fmt.Sprintf("%#v", this.Body)+",\n")
	}
	if this.FuncDoc != nil {
		s = append(s, "FuncDoc: "+fmt.Sprintf("%#v", this.FuncDoc)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *OTelDoc) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&docspb.OTelDoc{")
	if this.Body != nil {
		s = append(s, "Body: "+fmt.Sprintf("%#v", this.Body)+",\n")
	}
	if this.FuncDoc != nil {
		s = append(s, "FuncDoc: "+fmt.Sprintf("%#v", this.FuncDoc)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *StructuredDocs) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 11)
	s = append(s, "&docspb.StructuredDocs{")
	if this.MutationDocs != nil {
		s = append(s, "MutationDocs: "+fmt.Sprintf("%#v", this.MutationDocs)+",\n")
	}
	if this.TracepointDecoratorDocs != nil {
		s = append(s, "TracepointDecoratorDocs: "+fmt.Sprintf("%#v", this.TracepointDecoratorDocs)+",\n")
	}
	if this.TracepointFieldDocs != nil {
		s = append(s, "TracepointFieldDocs: "+fmt.Sprintf("%#v", this.TracepointFieldDocs)+",\n")
	}
	if this.DataframeOpDocs != nil {
		s = append(s, "DataframeOpDocs: "+fmt.Sprintf("%#v", this.DataframeOpDocs)+",\n")
	}
	if this.CompileFnDocs != nil {
		s = append(s, "CompileFnDocs: "+fmt.Sprintf("%#v", this.CompileFnDocs)+",\n")
	}
	if this.UdfDocs != nil {
		s = append(s, "UdfDocs: "+fmt.Sprintf("%#v", this.UdfDocs)+",\n")
	}
	if this.OTelDocs != nil {
		s = append(s, "OTelDocs: "+fmt.Sprintf("%#v", this.OTelDocs)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringDocs(v interface{}, typ string) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
}
func (m *IdentDoc) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *IdentDoc) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *IdentDoc) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Default) > 0 {
		i -= len(m.Default)
		copy(dAtA[i:], m.Default)
		i = encodeVarintDocs(dAtA, i, uint64(len(m.Default)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Types) > 0 {
		for iNdEx := len(m.Types) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Types[iNdEx])
			copy(dAtA[i:], m.Types[iNdEx])
			i = encodeVarintDocs(dAtA, i, uint64(len(m.Types[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Desc) > 0 {
		i -= len(m.Desc)
		copy(dAtA[i:], m.Desc)
		i = encodeVarintDocs(dAtA, i, uint64(len(m.Desc)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Ident) > 0 {
		i -= len(m.Ident)
		copy(dAtA[i:], m.Ident)
		i = encodeVarintDocs(dAtA, i, uint64(len(m.Ident)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *FuncDoc) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *FuncDoc) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FuncDoc) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ReturnType != nil {
		{
			size, err := m.ReturnType.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDocs(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.Kwargs != nil {
		{
			size, err := m.Kwargs.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDocs(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.RepeatedArgs != nil {
		{
			size, err := m.RepeatedArgs.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDocs(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Args) > 0 {
		for iNdEx := len(m.Args) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Args[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintDocs(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *DocstringNode) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DocstringNode) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DocstringNode) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Children) > 0 {
		for iNdEx := len(m.Children) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Children[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintDocs(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Docstring) > 0 {
		i -= len(m.Docstring)
		copy(dAtA[i:], m.Docstring)
		i = encodeVarintDocs(dAtA, i, uint64(len(m.Docstring)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintDocs(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *InternalPXLDocs) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *InternalPXLDocs) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *InternalPXLDocs) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.UdfDocs != nil {
		{
			size, err := m.UdfDocs.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDocs(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.DocstringNodes) > 0 {
		for iNdEx := len(m.DocstringNodes) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.DocstringNodes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintDocs(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *ExampleDoc) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ExampleDoc) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ExampleDoc) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Value) > 0 {
		i -= len(m.Value)
		copy(dAtA[i:], m.Value)
		i = encodeVarintDocs(dAtA, i, uint64(len(m.Value)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DocBody) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DocBody) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DocBody) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Examples) > 0 {
		for iNdEx := len(m.Examples) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Examples[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintDocs(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.Desc) > 0 {
		i -= len(m.Desc)
		copy(dAtA[i:], m.Desc)
		i = encodeVarintDocs(dAtA, i, uint64(len(m.Desc)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Brief) > 0 {
		i -= len(m.Brief)
		copy(dAtA[i:], m.Brief)
		i = encodeVarintDocs(dAtA, i, uint64(len(m.Brief)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintDocs(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MutationDoc) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MutationDoc) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MutationDoc) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.FuncDoc != nil {
		{
			size, err := m.FuncDoc.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDocs(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Body != nil {
		{
			size, err := m.Body.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDocs(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *TracepointDecoratorDoc) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TracepointDecoratorDoc) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TracepointDecoratorDoc) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.FuncDoc != nil {
		{
			size, err := m.FuncDoc.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDocs(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Body != nil {
		{
			size, err := m.Body.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDocs(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *TracepointFieldDoc) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TracepointFieldDoc) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TracepointFieldDoc) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.FuncDoc != nil {
		{
			size, err := m.FuncDoc.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDocs(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Body != nil {
		{
			size, err := m.Body.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDocs(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DataFrameOpDoc) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DataFrameOpDoc) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DataFrameOpDoc) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.FuncDoc != nil {
		{
			size, err := m.FuncDoc.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDocs(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Body != nil {
		{
			size, err := m.Body.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDocs(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *CompileFnDoc) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CompileFnDoc) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CompileFnDoc) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.FuncDoc != nil {
		{
			size, err := m.FuncDoc.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDocs(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Body != nil {
		{
			size, err := m.Body.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDocs(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *OTelDoc) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *OTelDoc) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *OTelDoc) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.FuncDoc != nil {
		{
			size, err := m.FuncDoc.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDocs(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Body != nil {
		{
			size, err := m.Body.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDocs(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *StructuredDocs) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *StructuredDocs) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *StructuredDocs) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.OTelDocs) > 0 {
		for iNdEx := len(m.OTelDocs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.OTelDocs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintDocs(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3a
		}
	}
	if len(m.CompileFnDocs) > 0 {
		for iNdEx := len(m.CompileFnDocs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.CompileFnDocs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintDocs(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	if len(m.DataframeOpDocs) > 0 {
		for iNdEx := len(m.DataframeOpDocs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.DataframeOpDocs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintDocs(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if m.UdfDocs != nil {
		{
			size, err := m.UdfDocs.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintDocs(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.TracepointFieldDocs) > 0 {
		for iNdEx := len(m.TracepointFieldDocs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.TracepointFieldDocs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintDocs(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.TracepointDecoratorDocs) > 0 {
		for iNdEx := len(m.TracepointDecoratorDocs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.TracepointDecoratorDocs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintDocs(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.MutationDocs) > 0 {
		for iNdEx := len(m.MutationDocs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.MutationDocs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintDocs(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func encodeVarintDocs(dAtA []byte, offset int, v uint64) int {
	offset -= sovDocs(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *IdentDoc) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Ident)
	if l > 0 {
		n += 1 + l + sovDocs(uint64(l))
	}
	l = len(m.Desc)
	if l > 0 {
		n += 1 + l + sovDocs(uint64(l))
	}
	if len(m.Types) > 0 {
		for _, s := range m.Types {
			l = len(s)
			n += 1 + l + sovDocs(uint64(l))
		}
	}
	l = len(m.Default)
	if l > 0 {
		n += 1 + l + sovDocs(uint64(l))
	}
	return n
}

func (m *FuncDoc) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Args) > 0 {
		for _, e := range m.Args {
			l = e.Size()
			n += 1 + l + sovDocs(uint64(l))
		}
	}
	if m.RepeatedArgs != nil {
		l = m.RepeatedArgs.Size()
		n += 1 + l + sovDocs(uint64(l))
	}
	if m.Kwargs != nil {
		l = m.Kwargs.Size()
		n += 1 + l + sovDocs(uint64(l))
	}
	if m.ReturnType != nil {
		l = m.ReturnType.Size()
		n += 1 + l + sovDocs(uint64(l))
	}
	return n
}

func (m *DocstringNode) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovDocs(uint64(l))
	}
	l = len(m.Docstring)
	if l > 0 {
		n += 1 + l + sovDocs(uint64(l))
	}
	if len(m.Children) > 0 {
		for _, e := range m.Children {
			l = e.Size()
			n += 1 + l + sovDocs(uint64(l))
		}
	}
	return n
}

func (m *InternalPXLDocs) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.DocstringNodes) > 0 {
		for _, e := range m.DocstringNodes {
			l = e.Size()
			n += 1 + l + sovDocs(uint64(l))
		}
	}
	if m.UdfDocs != nil {
		l = m.UdfDocs.Size()
		n += 1 + l + sovDocs(uint64(l))
	}
	return n
}

func (m *ExampleDoc) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovDocs(uint64(l))
	}
	return n
}

func (m *DocBody) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovDocs(uint64(l))
	}
	l = len(m.Brief)
	if l > 0 {
		n += 1 + l + sovDocs(uint64(l))
	}
	l = len(m.Desc)
	if l > 0 {
		n += 1 + l + sovDocs(uint64(l))
	}
	if len(m.Examples) > 0 {
		for _, e := range m.Examples {
			l = e.Size()
			n += 1 + l + sovDocs(uint64(l))
		}
	}
	return n
}

func (m *MutationDoc) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Body != nil {
		l = m.Body.Size()
		n += 1 + l + sovDocs(uint64(l))
	}
	if m.FuncDoc != nil {
		l = m.FuncDoc.Size()
		n += 1 + l + sovDocs(uint64(l))
	}
	return n
}

func (m *TracepointDecoratorDoc) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Body != nil {
		l = m.Body.Size()
		n += 1 + l + sovDocs(uint64(l))
	}
	if m.FuncDoc != nil {
		l = m.FuncDoc.Size()
		n += 1 + l + sovDocs(uint64(l))
	}
	return n
}

func (m *TracepointFieldDoc) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Body != nil {
		l = m.Body.Size()
		n += 1 + l + sovDocs(uint64(l))
	}
	if m.FuncDoc != nil {
		l = m.FuncDoc.Size()
		n += 1 + l + sovDocs(uint64(l))
	}
	return n
}

func (m *DataFrameOpDoc) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Body != nil {
		l = m.Body.Size()
		n += 1 + l + sovDocs(uint64(l))
	}
	if m.FuncDoc != nil {
		l = m.FuncDoc.Size()
		n += 1 + l + sovDocs(uint64(l))
	}
	return n
}

func (m *CompileFnDoc) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Body != nil {
		l = m.Body.Size()
		n += 1 + l + sovDocs(uint64(l))
	}
	if m.FuncDoc != nil {
		l = m.FuncDoc.Size()
		n += 1 + l + sovDocs(uint64(l))
	}
	return n
}

func (m *OTelDoc) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Body != nil {
		l = m.Body.Size()
		n += 1 + l + sovDocs(uint64(l))
	}
	if m.FuncDoc != nil {
		l = m.FuncDoc.Size()
		n += 1 + l + sovDocs(uint64(l))
	}
	return n
}

func (m *StructuredDocs) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.MutationDocs) > 0 {
		for _, e := range m.MutationDocs {
			l = e.Size()
			n += 1 + l + sovDocs(uint64(l))
		}
	}
	if len(m.TracepointDecoratorDocs) > 0 {
		for _, e := range m.TracepointDecoratorDocs {
			l = e.Size()
			n += 1 + l + sovDocs(uint64(l))
		}
	}
	if len(m.TracepointFieldDocs) > 0 {
		for _, e := range m.TracepointFieldDocs {
			l = e.Size()
			n += 1 + l + sovDocs(uint64(l))
		}
	}
	if m.UdfDocs != nil {
		l = m.UdfDocs.Size()
		n += 1 + l + sovDocs(uint64(l))
	}
	if len(m.DataframeOpDocs) > 0 {
		for _, e := range m.DataframeOpDocs {
			l = e.Size()
			n += 1 + l + sovDocs(uint64(l))
		}
	}
	if len(m.CompileFnDocs) > 0 {
		for _, e := range m.CompileFnDocs {
			l = e.Size()
			n += 1 + l + sovDocs(uint64(l))
		}
	}
	if len(m.OTelDocs) > 0 {
		for _, e := range m.OTelDocs {
			l = e.Size()
			n += 1 + l + sovDocs(uint64(l))
		}
	}
	return n
}

func sovDocs(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozDocs(x uint64) (n int) {
	return sovDocs(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *IdentDoc) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&IdentDoc{`,
		`Ident:` + fmt.Sprintf("%v", this.Ident) + `,`,
		`Desc:` + fmt.Sprintf("%v", this.Desc) + `,`,
		`Types:` + fmt.Sprintf("%v", this.Types) + `,`,
		`Default:` + fmt.Sprintf("%v", this.Default) + `,`,
		`}`,
	}, "")
	return s
}
func (this *FuncDoc) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForArgs := "[]*IdentDoc{"
	for _, f := range this.Args {
		repeatedStringForArgs += strings.Replace(f.String(), "IdentDoc", "IdentDoc", 1) + ","
	}
	repeatedStringForArgs += "}"
	s := strings.Join([]string{`&FuncDoc{`,
		`Args:` + repeatedStringForArgs + `,`,
		`RepeatedArgs:` + strings.Replace(this.RepeatedArgs.String(), "IdentDoc", "IdentDoc", 1) + `,`,
		`Kwargs:` + strings.Replace(this.Kwargs.String(), "IdentDoc", "IdentDoc", 1) + `,`,
		`ReturnType:` + strings.Replace(this.ReturnType.String(), "IdentDoc", "IdentDoc", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DocstringNode) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForChildren := "[]*DocstringNode{"
	for _, f := range this.Children {
		repeatedStringForChildren += strings.Replace(f.String(), "DocstringNode", "DocstringNode", 1) + ","
	}
	repeatedStringForChildren += "}"
	s := strings.Join([]string{`&DocstringNode{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Docstring:` + fmt.Sprintf("%v", this.Docstring) + `,`,
		`Children:` + repeatedStringForChildren + `,`,
		`}`,
	}, "")
	return s
}
func (this *InternalPXLDocs) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForDocstringNodes := "[]*DocstringNode{"
	for _, f := range this.DocstringNodes {
		repeatedStringForDocstringNodes += strings.Replace(f.String(), "DocstringNode", "DocstringNode", 1) + ","
	}
	repeatedStringForDocstringNodes += "}"
	s := strings.Join([]string{`&InternalPXLDocs{`,
		`DocstringNodes:` + repeatedStringForDocstringNodes + `,`,
		`UdfDocs:` + strings.Replace(fmt.Sprintf("%v", this.UdfDocs), "Docs", "udfspb.Docs", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ExampleDoc) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ExampleDoc{`,
		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DocBody) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForExamples := "[]*ExampleDoc{"
	for _, f := range this.Examples {
		repeatedStringForExamples += strings.Replace(f.String(), "ExampleDoc", "ExampleDoc", 1) + ","
	}
	repeatedStringForExamples += "}"
	s := strings.Join([]string{`&DocBody{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Brief:` + fmt.Sprintf("%v", this.Brief) + `,`,
		`Desc:` + fmt.Sprintf("%v", this.Desc) + `,`,
		`Examples:` + repeatedStringForExamples + `,`,
		`}`,
	}, "")
	return s
}
func (this *MutationDoc) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&MutationDoc{`,
		`Body:` + strings.Replace(this.Body.String(), "DocBody", "DocBody", 1) + `,`,
		`FuncDoc:` + strings.Replace(this.FuncDoc.String(), "FuncDoc", "FuncDoc", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *TracepointDecoratorDoc) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&TracepointDecoratorDoc{`,
		`Body:` + strings.Replace(this.Body.String(), "DocBody", "DocBody", 1) + `,`,
		`FuncDoc:` + strings.Replace(this.FuncDoc.String(), "FuncDoc", "FuncDoc", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *TracepointFieldDoc) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&TracepointFieldDoc{`,
		`Body:` + strings.Replace(this.Body.String(), "DocBody", "DocBody", 1) + `,`,
		`FuncDoc:` + strings.Replace(this.FuncDoc.String(), "FuncDoc", "FuncDoc", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DataFrameOpDoc) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DataFrameOpDoc{`,
		`Body:` + strings.Replace(this.Body.String(), "DocBody", "DocBody", 1) + `,`,
		`FuncDoc:` + strings.Replace(this.FuncDoc.String(), "FuncDoc", "FuncDoc", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *CompileFnDoc) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&CompileFnDoc{`,
		`Body:` + strings.Replace(this.Body.String(), "DocBody", "DocBody", 1) + `,`,
		`FuncDoc:` + strings.Replace(this.FuncDoc.String(), "FuncDoc", "FuncDoc", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *OTelDoc) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&OTelDoc{`,
		`Body:` + strings.Replace(this.Body.String(), "DocBody", "DocBody", 1) + `,`,
		`FuncDoc:` + strings.Replace(this.FuncDoc.String(), "FuncDoc", "FuncDoc", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *StructuredDocs) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForMutationDocs := "[]*MutationDoc{"
	for _, f := range this.MutationDocs {
		repeatedStringForMutationDocs += strings.Replace(f.String(), "MutationDoc", "MutationDoc", 1) + ","
	}
	repeatedStringForMutationDocs += "}"
	repeatedStringForTracepointDecoratorDocs := "[]*TracepointDecoratorDoc{"
	for _, f := range this.TracepointDecoratorDocs {
		repeatedStringForTracepointDecoratorDocs += strings.Replace(f.String(), "TracepointDecoratorDoc", "TracepointDecoratorDoc", 1) + ","
	}
	repeatedStringForTracepointDecoratorDocs += "}"
	repeatedStringForTracepointFieldDocs := "[]*TracepointFieldDoc{"
	for _, f := range this.TracepointFieldDocs {
		repeatedStringForTracepointFieldDocs += strings.Replace(f.String(), "TracepointFieldDoc", "TracepointFieldDoc", 1) + ","
	}
	repeatedStringForTracepointFieldDocs += "}"
	repeatedStringForDataframeOpDocs := "[]*DataFrameOpDoc{"
	for _, f := range this.DataframeOpDocs {
		repeatedStringForDataframeOpDocs += strings.Replace(f.String(), "DataFrameOpDoc", "DataFrameOpDoc", 1) + ","
	}
	repeatedStringForDataframeOpDocs += "}"
	repeatedStringForCompileFnDocs := "[]*CompileFnDoc{"
	for _, f := range this.CompileFnDocs {
		repeatedStringForCompileFnDocs += strings.Replace(f.String(), "CompileFnDoc", "CompileFnDoc", 1) + ","
	}
	repeatedStringForCompileFnDocs += "}"
	repeatedStringForOTelDocs := "[]*OTelDoc{"
	for _, f := range this.OTelDocs {
		repeatedStringForOTelDocs += strings.Replace(f.String(), "OTelDoc", "OTelDoc", 1) + ","
	}
	repeatedStringForOTelDocs += "}"
	s := strings.Join([]string{`&StructuredDocs{`,
		`MutationDocs:` + repeatedStringForMutationDocs + `,`,
		`TracepointDecoratorDocs:` + repeatedStringForTracepointDecoratorDocs + `,`,
		`TracepointFieldDocs:` + repeatedStringForTracepointFieldDocs + `,`,
		`UdfDocs:` + strings.Replace(fmt.Sprintf("%v", this.UdfDocs), "Docs", "udfspb.Docs", 1) + `,`,
		`DataframeOpDocs:` + repeatedStringForDataframeOpDocs + `,`,
		`CompileFnDocs:` + repeatedStringForCompileFnDocs + `,`,
		`OTelDocs:` + repeatedStringForOTelDocs + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringDocs(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *IdentDoc) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDocs
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: IdentDoc: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IdentDoc: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ident", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDocs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDocs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDocs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ident = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Desc", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDocs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDocs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDocs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Desc = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Types", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDocs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDocs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDocs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Types = append(m.Types, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Default", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDocs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDocs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDocs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Default = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDocs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDocs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FuncDoc) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDocs
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: FuncDoc: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FuncDoc: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Args", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDocs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDocs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDocs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Args = append(m.Args, &IdentDoc{})
			if err := m.Args[len(m.Args)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RepeatedArgs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDocs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDocs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDocs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RepeatedArgs == nil {
				m.RepeatedArgs = &IdentDoc{}
			}
			if err := m.RepeatedArgs.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Kwargs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDocs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDocs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDocs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Kwargs == nil {
				m.Kwargs = &IdentDoc{}
			}
			if err := m.Kwargs.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReturnType", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDocs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDocs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDocs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ReturnType == nil {
				m.ReturnType = &IdentDoc{}
			}
			if err := m.ReturnType.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDocs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDocs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DocstringNode) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDocs
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DocstringNode: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DocstringNode: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDocs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDocs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDocs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Docstring", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDocs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDocs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDocs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Docstring = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Children", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDocs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDocs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDocs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Children = append(m.Children, &DocstringNode{})
			if err := m.Children[len(m.Children)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDocs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDocs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *InternalPXLDocs) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDocs
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: InternalPXLDocs: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: InternalPXLDocs: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DocstringNodes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDocs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDocs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDocs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DocstringNodes = append(m.DocstringNodes, &DocstringNode{})
			if err := m.DocstringNodes[len(m.DocstringNodes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UdfDocs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDocs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDocs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDocs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.UdfDocs == nil {
				m.UdfDocs = &udfspb.Docs{}
			}
			if err := m.UdfDocs.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDocs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDocs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ExampleDoc) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDocs
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ExampleDoc: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ExampleDoc: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDocs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDocs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDocs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Value = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDocs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDocs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DocBody) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDocs
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DocBody: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DocBody: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDocs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDocs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDocs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Brief", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDocs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDocs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDocs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Brief = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Desc", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDocs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDocs
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDocs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Desc = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Examples", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDocs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDocs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDocs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Examples = append(m.Examples, &ExampleDoc{})
			if err := m.Examples[len(m.Examples)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDocs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDocs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MutationDoc) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDocs
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MutationDoc: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MutationDoc: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDocs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDocs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDocs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Body == nil {
				m.Body = &DocBody{}
			}
			if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FuncDoc", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDocs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDocs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDocs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FuncDoc == nil {
				m.FuncDoc = &FuncDoc{}
			}
			if err := m.FuncDoc.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDocs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDocs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TracepointDecoratorDoc) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDocs
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TracepointDecoratorDoc: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TracepointDecoratorDoc: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDocs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDocs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDocs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Body == nil {
				m.Body = &DocBody{}
			}
			if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FuncDoc", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDocs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDocs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDocs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FuncDoc == nil {
				m.FuncDoc = &FuncDoc{}
			}
			if err := m.FuncDoc.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDocs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDocs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TracepointFieldDoc) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDocs
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TracepointFieldDoc: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TracepointFieldDoc: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDocs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDocs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDocs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Body == nil {
				m.Body = &DocBody{}
			}
			if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FuncDoc", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDocs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDocs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDocs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FuncDoc == nil {
				m.FuncDoc = &FuncDoc{}
			}
			if err := m.FuncDoc.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDocs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDocs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DataFrameOpDoc) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDocs
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DataFrameOpDoc: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DataFrameOpDoc: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDocs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDocs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDocs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Body == nil {
				m.Body = &DocBody{}
			}
			if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FuncDoc", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDocs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDocs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDocs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FuncDoc == nil {
				m.FuncDoc = &FuncDoc{}
			}
			if err := m.FuncDoc.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDocs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDocs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CompileFnDoc) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDocs
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CompileFnDoc: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CompileFnDoc: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDocs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDocs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDocs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Body == nil {
				m.Body = &DocBody{}
			}
			if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FuncDoc", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDocs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDocs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDocs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FuncDoc == nil {
				m.FuncDoc = &FuncDoc{}
			}
			if err := m.FuncDoc.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDocs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDocs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *OTelDoc) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDocs
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: OTelDoc: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OTelDoc: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDocs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDocs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDocs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Body == nil {
				m.Body = &DocBody{}
			}
			if err := m.Body.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FuncDoc", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDocs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDocs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDocs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FuncDoc == nil {
				m.FuncDoc = &FuncDoc{}
			}
			if err := m.FuncDoc.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDocs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDocs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *StructuredDocs) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowDocs
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: StructuredDocs: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StructuredDocs: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MutationDocs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDocs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDocs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDocs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MutationDocs = append(m.MutationDocs, &MutationDoc{})
			if err := m.MutationDocs[len(m.MutationDocs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TracepointDecoratorDocs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDocs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDocs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDocs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TracepointDecoratorDocs = append(m.TracepointDecoratorDocs, &TracepointDecoratorDoc{})
			if err := m.TracepointDecoratorDocs[len(m.TracepointDecoratorDocs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TracepointFieldDocs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDocs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDocs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDocs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TracepointFieldDocs = append(m.TracepointFieldDocs, &TracepointFieldDoc{})
			if err := m.TracepointFieldDocs[len(m.TracepointFieldDocs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UdfDocs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDocs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDocs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDocs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.UdfDocs == nil {
				m.UdfDocs = &udfspb.Docs{}
			}
			if err := m.UdfDocs.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DataframeOpDocs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDocs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDocs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDocs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DataframeOpDocs = append(m.DataframeOpDocs, &DataFrameOpDoc{})
			if err := m.DataframeOpDocs[len(m.DataframeOpDocs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CompileFnDocs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDocs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDocs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDocs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CompileFnDocs = append(m.CompileFnDocs, &CompileFnDoc{})
			if err := m.CompileFnDocs[len(m.CompileFnDocs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OTelDocs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDocs
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDocs
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDocs
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OTelDocs = append(m.OTelDocs, &OTelDoc{})
			if err := m.OTelDocs[len(m.OTelDocs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDocs(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthDocs
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipDocs(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowDocs
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowDocs
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowDocs
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthDocs
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupDocs
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthDocs
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthDocs        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowDocs          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupDocs = fmt.Errorf("proto: unexpected end of group")
)
